{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Render\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "\n",
    "## 渲染程序框架\n",
    "![RUNOOB 图标](opengl.png)\n",
    "\n",
    "## 图形API\n",
    "### OpenGL\\OpenGLES\\WebGL https://learnopengl-cn.github.io/\n",
    "### DirectX\n",
    "### Vulkan\n",
    "### Metal\n",
    "\n",
    "## pipeline\n",
    "![pipeline ](http://www.it165.net/uploadfile/files/2015/1223/20151223191305257.png)\n",
    "\n",
    "![pipeline2](https://img-blog.csdnimg.cn/20210128172144333.png)\n",
    "\n",
    "\n",
    "## 顶点数据（Vertex Data）\n",
    "顶点数据用来为后面的顶点着色器等阶段提供处理的数据。是渲染管线的数据主要来源。送入到渲染管线的数据包括顶点坐标、纹理坐标、顶点法线和顶点颜色等顶点属性。为了让OpenGL明白顶点数据构成的是什么图元，我们需要在绘制指令中传递相对应的图元信息。常见的图元包括：点(GL_POINTS)、线(GL_LINES)、线条(GL_LINE_STRIP)、三角面(GL_TRIANGLES)。\n",
    "\n",
    "## 顶点着色器（Vertex Shader）\n",
    "顶点着色器主要功能是进行坐标变换。将输入的局部坐标变换到世界坐标、观察坐标和裁剪坐标。虽然我们也会在顶点着色器进行光照计算(称作高洛德着色)，然后经过光栅化插值得到各个片段的颜色，但由于这种方法得到的光照比较不自然，所以一般在片段着色器进行光照计算。\n",
    "\n",
    "### 世界坐标\n",
    "世界坐标是不会变的，一直以世界坐标轴的XYZ为标准。\n",
    "\n",
    "### 局部坐标\n",
    "所谓局部坐标系(Local Coordinate)，也就是坐标系以物体的中心为坐标原点，物体的旋转或平移等操作都是围绕局部坐标系进行的，这时，当物体模型进行旋转或平移等操作时，局部坐标系也执行相应的旋转或平移操作。\n",
    "\n",
    "### 观察坐标\n",
    "观察坐标系又称目坐标系( Eye Coordinates)，简称EC，该坐标系是一个可定义在用户坐标系中任何方向、任何地方的三维直角辅助坐标系。在观察坐标系中通常要定义一个垂直于该坐标系Z轴的平面，称观察平面。该坐标系主要用于指定裁剪空间，确定三维几何形体哪一部分需要在屏幕上输出；此外，通过观察平面可以把世界坐标系中三维几何形体需输岀部分的坐标值转换为规格化坐标系中的坐标值。\n",
    "\n",
    "### 裁剪坐标：\n",
    "在一个顶点着色器运行的最后，OpenGL期望所有的坐标都能落在一个特定的范围内，且任何在这个范围之外的点都应该被裁剪掉(Clipped)。被裁剪掉的坐标就会被忽略，所以剩下的坐标就将变为屏幕上可见的片段。这也就是裁剪空间(Clip Space)名字的由来。\n",
    "\n",
    "## 图元装配（Shape Assembly）\n",
    "图元组装将输入的顶点组装成指定的图元，包括点，线段，三角形等，是构成实体模型的基本单位。图元组装阶段会进行裁剪和背面剔除相关的优化，以减少进入光栅化的图元的数量，加速渲染过程。在光栅化之前，还会进行屏幕映射的操作：透视除法和视口变换。\n",
    "\n",
    "## 几何着色器（Geometry Shader）\n",
    "几何着色器也是渲染管线一个可选的阶段。我们知道，顶点着色器的输入是单个顶点(以及属性)， 输出的是经过变换后的顶点。与顶点着色器不同，几何着色器的输入是完整的图元(比如，点)，输出可以是一个或多个其他的图元(比如，三角面)，或者不输出任何的图元。几何着色器的拿手好戏就是将输入的点或线扩展成多边形。下图展示了几何着色器如何将点扩展成多边形。\n",
    "\n",
    "## 细分着色器（Tesselation shader(s)）\n",
    "曲面细分是利用镶嵌化处理技术对三角面进行细分，以此来增加物体表面的三角面的数量，是渲染管线一个可选的阶段。它由外壳着色器(Hull Shader)、镶嵌器(Tessellator)和域着色器(Domain Shader)构成，其中外壳着色器和域着色器是可编程的，而镶嵌器是有硬件管理的。我们可以借助曲面细分的技术实现细节层次(Level-of-Detail)的机制，使得离摄像机越近的物体具有更加丰富的细节，而远离摄像机的物体具有较少的细节。\n",
    "\n",
    "![pipeline3](https://img-blog.csdnimg.cn/2021012816230677.jpg)\n",
    "\n",
    "\n",
    "## 光栅化（Rasterization）\n",
    "光栅化是将几何数据经过一系列变换后最终转换为像素，从而呈现在显示设备上的过程。这是一个将模拟信号转化为离散信号的过程。\n",
    "光栅化过程产生的是片元，片元中的每一个元素对应于帧缓冲区中的一个像素。光栅化会确定图元所覆盖的片段，利用顶点属性插值得到片段的属性信息，然后送到片段着色器进行颜色计算，我们这里需要注意到片段是像素的候选者，只有通过后续的测试，片段才会成为最终显示的像素点。\n",
    "\n",
    "光栅化其实是一种将几何图元变为二维图像的过程。该过程包含了两部分的工作。\n",
    "第一部分工作：决定窗口坐标中的哪些整型栅格区域被基本图元占用；\n",
    "第二部分工作：分配一个颜色值和一个深度值到各个区域。\n",
    "![](https://img-blog.csdnimg.cn/20210128172240724.png)\n",
    "光栅化的本质是坐标变换、几何离散化，如下图：\n",
    "![](https://img-blog.csdnimg.cn/20210128172254621.png)\n",
    "\n",
    "## 片段着色器（Fragment Shader）\n",
    "片段着色器用来决定屏幕上像素的最终颜色。在这个阶段会进行光照计算以及阴影处理，是渲染管线高级效果产生的地方。在计算机图形中，颜色被表示为有4个元素的数据，RGBA（RGBA是代表Red（红色）Green（绿色）Blue（蓝色）和Alpha的色彩空间），当在OpenGL或者GLSL中定义一个颜色，我们把颜色每个分量的强度设置在0.0到1.0之间。\n",
    "\n",
    "## 测试与混合（Tests And Blending）\n",
    "管线的最后一个阶段是测试混合阶段。测试包括裁切测试、Alpha测试、模板测试和深度测试。没有经过测试的片段会被丢弃，不需要进行混合阶段；经过测试的片段会进入混合阶段。Alpha混合可以根据片段的alpha值进行混合，用来产生半透明的效果，这些测试与混合操作决定了屏幕视窗上每个像素点最终的颜色以及透明度。\n",
    "Alpha表示的是物体的不透明度，因此alpha=1表示完全不透明，alpha=0表示完全透明。测试混合阶段虽然不是可编程阶段，但是我们可以通过OpenGL或DirectX提供的接口进行配置，定制混合和测试的方式。\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# vispy https://vispy.org/"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "4933e7b805964473a7ffa5a4201da30e",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "RFBOutputContext()"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/html": [
       "<div class='initial-snapshot-339ed18d817c4095b77c44b5419e3e9f' style='position:relative;'><img src='' style='width:800.0px;height:300.0px;' /><div style='position: absolute; top:0; left:0; padding:1px 3px; background: #777; color:#fff; font-size: 90%; font-family:sans-serif; '>initial snapshot</div></div>"
      ],
      "text/plain": [
       "<jupyter_rfb._utils.Snapshot object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "339ed18d817c4095b77c44b5419e3e9f",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "CanvasBackend(css_width='800px')"
      ]
     },
     "execution_count": 8,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "import numpy as np\n",
    "import glm\n",
    "from vispy import app, gloo, visuals,io\n",
    "from vispy.gloo import Program, VertexBuffer, IndexBuffer\n",
    "from vispy.util.transforms import perspective, translate, rotate,frustum,perspective,ortho\n",
    "from vispy.geometry import create_cube\n",
    "\n",
    "\n",
    "\n",
    "vertexcb = \"\"\"\n",
    "uniform mat4 model;\n",
    "uniform mat4 view;\n",
    "uniform mat4 projection;\n",
    "attribute vec3 position;\n",
    "attribute vec3 color;\n",
    "varying vec4 v_color;\n",
    "void main()\n",
    "{\n",
    "    v_color =vec4((color+vec3(1.0,1.0,1.0)/2.0),0.5);\n",
    "    gl_Position =projection*view*model* vec4(position/2.0, 1.0);\n",
    "}\n",
    "\n",
    "\"\"\"\n",
    "\n",
    "fragmentcb = \"\"\"\n",
    "varying vec4 v_color;\n",
    "void main()\n",
    "{\n",
    "    gl_FragColor =v_color;//vec4(1.0,0.0,0.0,0.0);\n",
    "}\n",
    "\"\"\"\n",
    "\n",
    "class Canvas(app.Canvas):\n",
    "    def __init__(self):\n",
    "        app.Canvas.__init__(self, size=(800, 300), title='Colored cube',\n",
    "                            keys='interactive')\n",
    "\n",
    "        # Build cube data\n",
    "        V, I, normals, nothing = io.read_mesh(\"../allobj/997.obj\")\n",
    "#         V, I, _ = create_cube()\n",
    "        vertices = VertexBuffer(V)\n",
    "\n",
    "        self.phi =0\n",
    "        self.theta =0\n",
    "        # Build view, model, projection & normal\n",
    "      \n",
    "#         view = translate((0.0, 0.0, -1.8))\n",
    "        view=glm.transpose(glm.lookAt(glm.vec3(0.,0.0,-2.80),glm.vec3(0.,0.0,0.0),glm.vec3(0.0,1.0,0)))\n",
    "\n",
    "        # Add colorbar\n",
    "        self.programcb = Program(vertexcb, fragmentcb)\n",
    "        self.model = np.eye(4, dtype=np.float32)\n",
    "        self.programcb['model'] = self.model\n",
    "        self.programcb['view'] = view    \n",
    "        gloo.set_viewport(0, 0, self.physical_size[0], self.physical_size[1])\n",
    "\n",
    "        self.programcb['position'] =   [[1, 1, 1], [-1, 1, 1], [-1, -1, 1], [1, -1, 1],\n",
    "         [1, -1, -1], [1, 1, -1], [-1, 1, -1], [-1, -1, -1]]\n",
    "        self.programcb['color'] =   [[1, 1, 1], [-1, 1, 1], [-1, -1, 1], [1, -1, 1],\n",
    "         [1, -1, -1], [1, 1, -1], [-1, 1, -1], [-1, -1, -1]]\n",
    "        self.indicescb = IndexBuffer([[0,1,2],[2,3,0],[0,3,4],[0,4,5],[2,7,4],[3,2,4],[1,0,5],[1,5,6],[4,7,6],[4,6,5],[1,6,7],[2,1,7]])\n",
    "\n",
    "        gloo.set_state(clear_color=(0.0, 0.0, 0.0, 1.00),blend=True,  depth_test=True)\n",
    "        self.activate_zoom()\n",
    "        self.timer = app.Timer('auto', self.on_timer, start=True)\n",
    "\n",
    "        self.prepos=[0,0]\n",
    "        self.show()\n",
    "\n",
    "    def on_draw(self, event):\n",
    "#         gloo.set_depth_mask(True)\n",
    "        gloo.clear(color=True, depth=True)\n",
    "#         self.testText.draw(self.tr_sys) #draw text\n",
    "#         self.program.draw('triangles', self.indices) #draw the cube\n",
    "        self.programcb.draw('triangles', self.indicescb) # draw the colorbar\n",
    "\n",
    "    \n",
    "    def on_resize(self, event):\n",
    "\n",
    "        self.activate_zoom()\n",
    "        self.update()\n",
    "\n",
    "    def activate_zoom(self):\n",
    "#         print(*self.physical_size)\n",
    "#         gloo.set_viewport(0, 0, *self.physical_size)\n",
    "        gloo.set_viewport(0, 0, self.physical_size[0], self.physical_size[1])\n",
    "\n",
    "        self.projection = perspective(60.0, self.size[0] / float(self.size[1]),0.001, 10000.0)\n",
    "\n",
    "        self.programcb['projection'] = self.projection\n",
    "        \n",
    "    def on_mouse_move(self, event):\n",
    "        if event.button==1:\n",
    "            self.phi += -self.prepos[0]+event.pos[0]\n",
    "            self.theta +=  -self.prepos[1]+event.pos[1]\n",
    "            self.model = np.dot(rotate(self.theta/1.0, (1, 0, 0)),\n",
    "                                           rotate(self.phi/1.0, (0, 1, 0)))\n",
    "            self.programcb['model'] = self.model\n",
    "            self.prepos=event.pos\n",
    "            self.update()\n",
    "        pass\n",
    "    def on_key_press(self, event):\n",
    "        if event.text == ' ':\n",
    "            if self.timer.running:\n",
    "                self.timer.stop()\n",
    "            else:\n",
    "                self.timer.start()\n",
    "            \n",
    "    def on_timer(self, event):\n",
    "\n",
    "        \n",
    "        self.update()\n",
    "        \n",
    "win = Canvas()\n",
    "win.show()\n",
    "win    "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# navis https://navis.readthedocs.io/en/latest/source/tutorials/plotting.html#d-plots"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "Plot neurons:   0%|          | 0/5 [00:00<?, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x432 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "import navis\n",
    "import matplotlib.pyplot as plt\n",
    "\n",
    "nl = navis.example_neurons(kind='skeleton')\n",
    "\n",
    "# Plot using default settings\n",
    "fig, ax = nl.plot2d()  # equivalent to `navis.plot2d(nl)`\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "Plot neurons:   0%|          | 0/5 [00:00<?, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x432 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "fig, ax = nl.plot2d(method='3d_complex')\n",
    "ax.azim, ax.elev = -90, -90\n",
    "# Zoom in a bit\n",
    "ax.dist = 6\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "Plot neurons:   0%|          | 0/5 [00:00<?, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x432 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "# Load the Lateral Horn (\"LH\") volume\n",
    "lh = navis.example_volume('LH')\n",
    "# Adjust color and alpha if you like\n",
    "lh.color = (0, 1, 0, .1)\n",
    "# Plot\n",
    "fig, ax = navis.plot2d([nl ,lh], method='3d_complex')\n",
    "ax.elev = ax.azim = -90\n",
    "ax.dist = 6\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [],
   "source": [
    "viewer = nl.plot3d(backend='vispy')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "navis",
   "language": "python",
   "name": "navis"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.7.13"
  },
  "toc": {
   "base_numbering": 1,
   "nav_menu": {},
   "number_sections": true,
   "sideBar": true,
   "skip_h1_title": false,
   "title_cell": "Table of Contents",
   "title_sidebar": "Contents",
   "toc_cell": false,
   "toc_position": {},
   "toc_section_display": true,
   "toc_window_display": true
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}
